Rücksprungadresse verändern

Hallo, ich habe folgenden Code und weiß nicht warum er bei mir nicht funktioniert.
Ich würde gerne die Rücksprungadresse verändern der funktion function und zwar so dass eine endlosschleife entsteht wenn ich sie aufrufe.

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

void catargs(int argc, char** argv) {
        int* ret;
        char buffer[8];
        //char *b = buffer;
        //int i;
        //int* ret;

        ret = (int*)buffer + 4;
        (*ret) -= 4;
        printf("Ret Adresse:%#x , Arg = %d\n", &ret, 2);

        //printf("buffer: %10.8p\n",&buffer);
        //printf("Alle zusammen: %s\n", buffer);

        //for (i=16;i>=4;i--)
//              printf("%10.8p: %10.8p\n",(long*)(((long*)&buffer)+i),(long*)                    
                //(*(((long*)&buffer)+i)));
        return (void)ret;

}

int main(int argc, char** argv) {
        catargs(argc, argv);
}

c.rackwitz

buffer+4 ist noch innerhalb von buffer

(char*)(&ret)+4 oder +8 ist was du willst.

Ich glaube folgender Code istbesser,
hier funktioniert das manipulieren aber ne schleife schaffe ich noch nicht..

/* bufferoverflow4.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void funktion(int tmp,char *array) {
   char puffer[5];
   int *pointer;

   strcpy(puffer, array);
   printf("%s\n",puffer);

   // pointer auf dem Stack 4 Bytes zurück. Sollt auf Rücksprungadresse zeigen
   pointer=&tmp-1;

   //Rücksprungadresse, auf die Pointer zeigt, 10 Bytes weiter
   //*pointer=*pointer+10;
}

int main(void) {
   int a;

   a=0;
   funktion(7,"hallo");

   a=1;
   printf("wert = %d\n",a);

   return EXIT_SUCCESS;
}

Hallo,
ich habe ein buffer_overlflow prog:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

void catargs(int argc, char** argv) {
        char buffer[32];
        char *b = buffer;
        int i;

        for(i=1; i<argc; i++) {
                strcpy(b, argv[i]);
                b += strlen(argv[i]);
                if(i+1 != argc) *b++ = ';';
        }

        int* ret;
        printf("Buffer: %#x\n", &buffer);
        ret = &argc -1;

        printf("Wohin zeigt RSA:%#x\n", &(*ret));
        (*ret) -= 8;
}

int main(int argc, char** argv) {
        catargs(argc, argv);
}

und ein kleines wrapper.c programm:

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

#define APPNAME "<pfad zu buffer_overlflow.o/buffer_overflow.o"

int main(int argc, char** argv) {
        char buffer[45];
        int i;

        for (i=0;i<44;i++) buffer[i] = 'a';

        printf("Execl '%s' ...\n",APPNAME);
        i = execl("./buffer_overflow.o",buffer,(char*)NULL);
        printf("\n***Buffer Overlow test done!***\n");
}

In buffer_overflow.c wird die Rücksprungadresse so manipuliert dass eine endlosschleife entsethet. Die Rücksprungadresse zeigt auf (in) die Funktion selbst.

Meine Frage ist nun. Eigentlich macht der Buffer_Overflow gar nichts. Bzw. ich nutze den buffer overflow gar nicht aus um die endlosschleife zu generieren weil ich ja einfach hart den Rücksprung manipuliere.

Gibt es eine möglichkeit genau so den buffer-overflow auszunutzen dass ich die rücksprungadresse nicht hardcodiert manipuliere sondern genau durch den buffer-overflow die schleife entsteht?

Also dass, wenn ich z.b das programm mit weniger zeichen ausführe und damit kein buffer-overflow entsteht alles normal durchläuft und erst wenn ich zuviel zeichen in den buffer packe die schleife entsteht???

Danke für Ratschläge

keiner ne Idee oder nen Ratschlag?

Es gibt keine Standard-Position, wo der Compiler sich die Rücksprung-Adresse einer Funktion merkt, d.h. jeder Compiler kann da etwas eigenes entwickeln (und die passenden Maschinen-Kommandos einfügen, um diese Adresse zu speichern und auszulesen). Aber selbst wenn du es schaffst, das Ziel des return "umzubiegen", zerlegst du eher deinen Programmstack als eine Endlosschleife zu bekommen (außer einem "goto caller" räumt das return nämlich noch die lokalen Variablen hinter dir auf).

Im Klartext: Ehe du mit solchen nichtportablen und potentiell lebensgefährlichen Zeigerbasteleien anfängst, bau dir doch einfach eine reguläre Endlosschleife:

while(true)
{
  //Anweisungen
}