To better explain where we actually go in terms of attack and memory exploits,
we have to understand that there's two primary areas of the actual running memory that we look
at in terms of viable for attack and also viable to the operating system for those that are doing
programming and other coding adventures. First, we want to address that this is broken down into
either the stack or the heap. Now, you may be wondering those are some goofy names and yes,
they really are but they've been around for quite some time and I'm going to break them down pretty
easily. The stack is the organized area of the actual RAM itself. This is where local variables
and function calls go. It's basically referred to as the last in and first out. So, this is where
stacked based stuff like buffer overflows get to happen at. So, whenever we send a buffer overflow
attack, it will happen in the stack of the actual memory itself. It's the easiest place to start
because of the data that we put in for actual controls and it sits right next to each other.
So, basically, we send a knot sled in and it's going to start pushing things in front of it out
the other end of the buffer itself causing that overflow. And then you have the heap which is
known as the chaotic area. It's almost like they were thinking of me. But inside the heap, we have
dynamic memory. Now, this is memory allocated to things on the fly and it's way less structured.
So, you'll see parts, bits, pieces of fragmented memory all throughout the area and it's not
necessarily because something got closed and we still have pieces left, but that is a part of it.
And that's where we can do some information and data carving out of things later on, especially
in those digital forensics courses here on CBT Nuggets using programs like volatility and etc.
But this is where heap overflows happen. And this is use after free exploits. So, basically,
we're sending in exploits, not buffer overflow, but we're sending in things into the memory,
specifically the heap area for us to call upon again later if it gets called back up or if we're
wanting to go through and do some very detailed data carving. And the reason I'm stressing this
part right here is because this is where the hardest level of attacks happen at when we look
at terms of attacking the actual memory itself. Now, I just wanted to give a real quick synopsis
of it because I really want to go into more detailed explanation here.