within the topic of stack buffer overflows, an often-discussed-but-rarely-seen architecture is one in which the stack grows in the opposite direction. this change in architecture is frequently suggested as a solution to the stack buffer overflow problem because any overflow of a stack buffer that occurs within the same stack frame can not overwrite the return pointer. further investigation of this claimed protection finds it to be a naïve solution at best. any overflow that occurs in a buffer from a previous stack frame will still overwrite a return pointer and allow for malicious exploitation of the bug. for instance, in the example above, the return pointer for codice_7 will not be overwritten because the overflow actually occurs within the stack frame for codice_8. however, because the buffer that overflows during the call to codice_8 resides in a previous stack frame, the return pointer for codice_8 will have a numerically higher memory address than the buffer. this means that instead of the return pointer for codice_7 being overwritten, the return pointer for codice_8 will be overwritten. at most, this means that growing the stack in the opposite direction will change some details of how stack buffer overflows are exploitable, but it will not reduce significantly the number of exploitable bugs.