C ->Buffer Overflow

[Mat]

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

[gorba]

is das hier n cracker forum? -.-

[quinte17]

durch zufällige verlängerung deines chars wird wohl kaum eine schleife entstehen, da ist immer etwas kontrolliertes gefragt... also so einfach ist es nicht.
man kann ja auch nicht immer sicher sagen, dass nach einer bestimmten anzahl an bytes genau diese rücksprungadresse dort reingeschrieben wird..
trifft zwar oft zu, aber halt nicht immer...
vielleicht findest du ja eine möglichkeit, indem du die funktionsadresse deiner funktion auf die rücksprungadresse bringst...

greetz

ps: mit cracken hat das nichts zu tun. dies hat etwas mit den grundprinzipien der system-architektur zu tun. hier ist eine möglichkeit solche stacksmashing attacks zu unterbinden: http://www.trl.ibm.com/projects/security/ssp/

[davidbaumann]

Ich glaube www.buha.info wäre auch ne gute Anlaufadresse für dich

David