Re: A way to prevent buffer overflow exploits?

> I wonder how feasible it would be to modify GCC to generate code with
> two stacks (or something equivalent): one for local variables, the
> other for parameters and return addresses. Might moving the local
> variables away from the return addresses this way be a relatively cheap
> way to prevent buffer overflow exploits without having to recode all of
> the applications or using expensive bounds-checking?


It is not necessarily cheap. An extra page is required for the stack in
the cache. For machines with small numbers of pages in the primary
cache, this can get expensive.


A similar scheme can be useful with languages which allow variable size
objects on the stack. Stack based languages with first class
polymorphism, for example and languages with runtime parameterized
types. All objects of variable size get put on the second stack. This is
especially useful for variable sized function results as it saves a copy
upon function return.




Incidentally, the only member of this class of stack based languages
languages with first class polymorphism I know of is Ada 95. By first
class polymorphism I mean that it is possible to declare variables to
have polymorphic types in exactly the same situations that you can
declare objects of exact types. If there are other languages in the
class, please draw my attention to them. The two popular languages of
the moment are not; all Java objects are on the heap and C++ does not
have first class polymorphism.
--

Return to the comp.compilers page.
Search the comp.compilers archives again.