How can I invoke buffer overflow?

Question

I got a homework assignment asking me to invoke a function without explicitly calling it, using buffer overflow. The code is basically this:

#include <stdio.h> #include <stdlib.h>  void g() {     printf("now inside g()!\n"); }   void f() {        printf("now inside f()!\n");     // can only modify this section     // cant call g(), maybe use g (pointer to function) }  int main (int argc, char *argv[]) {     f();     return 0; } 

Though I'm not sure how to proceed. I thought about changing the return address for the program counter so that it'll proceed directly to the address of g(), but I'm not sure how to access it. Anyway, tips will be great.

Answer 1

The basic idea is to alter the function's return address so that when the function returns is continues to execute at a new hacked address. As done by Nils in one of the answers, you can declare a piece of memory (usually array) and overflow it in such a way that the return address is overwritten as well.

I would suggest you to not blindly take any of the programs given here without actually understanding how they work. This article is very well written and you'll find it very useful:

A step-by-step on the buffer overflow vulnerablity

Answer 2

That is compiler dependent, so no single answer can be given.

The following code will do what you want for gcc 4.4.1. Compile with optimizations disabled (important!)

#include <stdio.h> #include <stdlib.h>  void g() {     printf("now inside g()!\n"); }   void f() {      int i;   void * buffer[1];   printf("now inside f()!\n");    // can only modify this section   // cant call g(), maybe use g (pointer to function)    // place the address of g all over the stack:   for (i=0; i<10; i++)      buffer[i] = (void*) g;    // and goodbye.. }  int main (int argc, char *argv[]) {     f();     return 0; } 

Output:

nils@doofnase:~$ gcc overflow.c nils@doofnase:~$ ./a.out now inside f()! now inside g()! now inside g()! now inside g()! now inside g()! now inside g()! now inside g()! Segmentation fault