Memory Management

Memory management represents a vital part of secure application

development. Proper memory management is like good personal hygiene.
We are physically healthier when we practice proper hygiene. Similarly,
applications perform better when memory use is properly allocated.

Buffer Overflow Zeroing Out Memory

A buffer overflow is simply allocating an array
of memory onto the call stack—the data
structure where methods and functions are
stored—and then overfilling it with more data
than it was supposed to handle. The extra
bytes written to memory spill over and overwrite
adjacent memory, usually corrupting other
stack-based variables. In severe cases a buffer
overflow will corrupt the call stack, leading to
a massive crash. Even worse, if an attacker has
access to the source code, they could deduce
a way to corrupt the call stack just enough to
change the value of a variable that normal code
could not reach, such as changing the privileges
of a user to that of an admin.
Setting Pointers to Null
One of the benefits of programming with C and
C++ is their use of pointers (with the attendant
speed boosts they provide). But pointers can also
create security holes if not properly addressed.
To null out a pointer is to assign it a value of
zero or some other compiler-directed value.
This disassociates the pointer with the region of
memory it previously pointed to. When you are
done with memory and you have zeroed it out,
assign zero to your pointer. That is the classic
Programming near the assembly layer at a low
level like in C or C++ leaves a lot of hygiene duties
in the hands of programmers rather than the
underlying system. To “zero out” memory is to
fill in a region of memory with zeros, ones,
or some pattern to erase what was in there
before. It should be obvious that if you have
memory pointing to a password, bank account
numbers, or some other confidential information,
that memory should be cleared out immediately
when finished.
For instance, if your application crashes, an
external application can collect a dump by
sweeping up and copying all the system memory.
That memory could then be saved to a file, where
an attacker could have ample time to search it for
sensitive data.
Thus, when you are done with sensitive memory,
take special care to clean up after yourself!
Memory Leaks
A memory leak occurs when a developer fails
to free an allocated block of memory when
no longer needed. An application littered with
memory leaks will eventually request a memory
chunk and fail, because the address space is

© 2021 The Security Awareness Company - KnowBe4, Inc. All rights reserved.
indication that the pointer is no longer in use. fragmented into tiny pieces.

The security implications of this process are huge. Dynamic Memory

You could have special password memory that
perhaps you didn’t free or fill in with zeros; if you
fail to null out a pointer to it, you leave clues as
to where that memory is (or was) located. That
would be like leaving a sign posted in your yard
telling everyone where the extra key to your front
door is hidden.
Allocating memory on the stack is easy to
clean up afterwards, since the compiler does it
for you. As the stack unwinds, the memory is
automatically freed. Memory allocated on the
heap is different; it is not automatically freed
and you have to do it manually.

Good memory management not only improves the way your application functions, it also
helps reduce security risks and is an imperative part of secure application development.