How to turn off gcc compiler optimization to enable buffer overflow

Home / How to turn off gcc compiler optimization to enable buffer overflow
15 Dec

How to turn off gcc compiler optimization to enable buffer overflow

up vote55down votefavorite

35

I’m working on a homework problem that requires disabling compiler optimization protection for it to work. I’m using gcc 4.4.1 on ubuntu linux, but can’t figure out which flags are are the right ones. I realize it’s architecture dependant – my machine runs w/ 32-bit Intel processor.

Thanks.

   

6 Answers

up vote73down voteaccepted

That’s a good problem. In order to solve that problem you will also have to disable ASLR otherwise the address of g() will be unpredictable.

Disable ASLR:

sudo bash -c 'echo 0 > /proc/sys/kernel/randomize_va_space'

Disable canaries:

gcc overflow.c -o overflow -fno-stack-protector

After canaries and ASLR are disabled it should be a straight forward attack like the ones described in Smashing the Stack for Fun and Profit

Here is a list of security features used in ubuntu: https://wiki.ubuntu.com/Security/Features You don’t have to worry about NX bits, the address of g() will always be in a executable region of memory because it is within the TEXT memory segment. NX bits only come into play if you are trying to execute shellcode on the stack or heap, which is not required for this assignment.

Now go and clobber that EIP!
4
thanks, I’ll do just that 🙂 Oh – how do I re-enable the protection to un-crap my machine?.. My guess is sudo echo 1 > /proc/sys/kernel/randomize_va_space – sa125 Feb 28 ’10 at 7:23
@sa125 yep, thats how its re-enabled. In fact thats how you switch on and off other kernel modules while the system is running 😉 – rook Feb 28 ’10 at 17:41
9
Seems worth pointing out that on my system randomize_va_space defaulted to 2, not 1, so it’s worth checking beforehand if you intend to re-enable it. – Rushyo Dec 1 ’11 at 16:28
2
Actually the address of g() will very likely not be randomized by ASLR as it is part of the main binary. Only if you compile the binary with -PIE will it be randomized. – Robert Larsen Dec 15 ’15 at 11:38

up vote26down vote

Urm, all of the answers so far have been wrong with Rook’s answer being correct.

Entering:

sudo echo 0 > /proc/sys/kernel/randomize_va_space

Followed by:

gcc -fno-stack-protector -z execstack -o bug bug.c

Disables ASLR, SSP/Propolice and Ubuntu’s NoneXec (which was placed in 9.10, and fairly simple to work around see the mprotect(2) technique to map pages as executable and jmp) should help a little, however these “security features” are by no means infallible. Without the `-z execstack’ flag, pages have non-executable stack markings.
3
You did not read the guys link. If you did you would know that he is trying to execute g() which is a function that is compiled into the binary. This is an address of a function. NX bits come into play when you are trying to execute shellcode on the heap or stack, his attack is far more simple. – rook Feb 26 ’10 at 16:04
I agree that everyone else is completely wrong, its obvious that we are the only 2 that have exploited a buffer overflow. However i still think my answer is more correct. – rook Feb 26 ’10 at 16:12
Hmm, just came across the link — I thought it was just another generic, you’re correct. I apologise. – Muhammed Mustapha Abiola Feb 26 ’10 at 20:43
No worries man I gave you a +1 because you know whats up. – rook Feb 26 ’10 at 21:02
I know this is a old post, but you can’t use sudo with > < because it will not allow it. The command should be:echo 0 | sudo tee /proc/sys/kernel/randomize_va_space – Boogy Nov 22 ’16 at 9:45

up vote9down vote

On newer distros (as of 2016), it seems that PIE is enabled by default so you will need to disable it explicitly when compiling.

Here’s a little summary of commands which can be helpful when playing locally with buffer overflow exercises in general:

Disable canary:

gcc vuln.c -o vuln_disable_canary -fno-stack-protector

Disable DEP:

gcc vuln.c -o vuln_disable_dep -z execstack

Disable PIE:

gcc vuln.c -o vuln_disable_pie -no-pie

Disable all of protection mechanisms listed above (warning: for local testing only):

gcc vuln.c -o vuln_disable_all -fno-stack-protector -z execstack -no-pie

For 32-bit machines, you’ll need to add the -m32 parameter as well.

up vote5down vote

Try the -fno-stack-protector flag.

up vote4down vote

I know it’s an old thread, but I want to point out that you don’t need to disable ASLR in order to do a buffer overflow! Although ASLR is Enabled(kernel_randomize_va_space = 2) it will not take effect unless the compiled executable is PIE, so unless u compiled your file with -fPIC -pie flag, ASLR will not take effect.

I think only disabling the canaries with -fno-stack-protector is enough. If you want to check if ASLR is working or not(Position independent code must be set), use: hardening-check executable_name

up vote2down vote

I won’t quote the entire page but the whole manual on optimisation is available here: http://gcc.gnu.org/onlinedocs/gcc-4.4.3/gcc/Optimize-Options.html#Optimize-Options

From the sounds of it you want at least -O0, the default, and:

-fmudflap -fmudflapth -fmudflapir

For front-ends that support it (C and C++), instrument all risky pointer/array dereferencing operations, some standard library string/heap functions, and some other associated constructs with range/validity tests. Modules so instrumented should be immune to buffer overflows, invalid heap use, and some other classes of C/C++ programming errors. The instrumentation relies on a separate runtime library (libmudflap), which will be linked into a program if -fmudflap is given at link time. Run-time behavior of the instrumented program is controlled by the MUDFLAP_OPTIONS environment variable. See env MUDFLAP_OPTIONS=-help a.out for its options.

Comments are closed.