Stackaufbau unter FC5? oder i686?

[redliner]

Morgen!

Ich lese gerade etwas über Stack Buffer Overflows und wollte halt ein paar sachen versuchen... aber ohne erfolg... ich versuche schon auf brutale methode die return adresse zu überschreiben:

#include <stdio.h>

void hallo()
{
  printf("Return adresse erfolgreich geändert :P\n");
}

int main()
{
   int *ret;
   int i = -100;

   while(i<100)
   {
     ret = (int *)&ret + i;
     (*ret) = (int)hallo;
     i++; 
  }
}

Ich hab hier FC5 und eine Intel Core Duo (ist doch i686 oder?).
Kann mir jemand helfen?

 

[Keruskerfürst]

Intel Core Duo ist Intel EMT64 und nicht i686 (zumindest im 64 Bit Modus).

 

[hex]

Core Duo muss nicht 64 Bit sein! Ich hab einen T2300 in meinem Notebook und kein 64 Bit!

mfg hex

 

[theton]

Morgen!

Ich lese gerade etwas über Stack Buffer Overflows und wollte halt ein paar sachen versuchen... aber ohne erfolg... ich versuche schon auf brutale methode die return adresse zu überschreiben:

#include <stdio.h>

void hallo()
{
  printf("Return adresse erfolgreich geändert :P\n");
}

int main()
{
   int *ret;
   int i = -100;

   while(i<100)
   {
     ret = (int *)&ret + i;
     (*ret) = (int)hallo;
     i++; 
  }
}

Ich hab hier FC5 und eine Intel Core Duo (ist doch i686 oder?).
Kann mir jemand helfen?

Dir ist aber schon klar, dass du auf diese Weise die Return-Adresse nicht überschreiben wirst? Dein Programm überschreitet ja seinen erlaubten Speicherbereich nicht. Dazu müsstest du erstmal die Return-Adresse deines Programms ermitteln um sie zu überschreiben oder Daten in einen Buffer schreiben, die dort nicht reinpassen, was aber auch nur zu einem SIGSEGV führen wird. Ein int wird immer in einen für int reservierten Speicher passen. Du solltest daher eher mit Strings arbeiten. Mir ist total unklar, warum man in seinem eigenen Programm einen Overflow auslösen möchte. Im Normalfall tut man das in SUID-Programmen oder Daemonen, die mit erweiterten Rechten laufen. Lies einfach mal das legendäre Smashing the Stack for Fun and Profit von Aleph1 um dir mal den Aufbau von Stacks und die Möglichkeiten von Overflows klarzumachen. Ausserdem solltest du dich mal ein wenig mit der Speicherverwaltung beschäftigen. Dann wird dir evtl. auch klar, warum man ein int nicht mit einem int zum Overflow bringen kann.

 

[redliner]

Joa... das da ist ja auch fast von aleph one... ich habs nur etwas geändert weil es bei mir nicht gefunzt hat.. das ist der original code:

/* By Aleph One */
char shellcode[] =
	"\xeb\x2a\x5e\x89\x76\x08\xc6\x46\x07\x00\xc7\x46\x0c\x00\x00\x00"
	"\x00\xb8\x0b\x00\x00\x00\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80"
	"\xb8\x01\x00\x00\x00\xbb\x00\x00\x00\x00\xcd\x80\xe8\xd1\xff\xff"
	"\xff\x2f\x62\x69\x6e\x2f\x73\x68\x00\x89\xec\x5d\xc3";

void main() {
   int *ret;

   ret = (int *)&ret + 2;
   (*ret) = (int)shellcode;

}

 

[redliner]

Ok, wie es aussieht hat mein Prozessor irgendwie ne Stack Overflow shutz oder so... auf meinem Desktop PC funzt das was ich will, aber nur auf dem lappy (Intel Core Duo) nicht!

 

[slash-ex]

löl.... ihr seit schon lustig... das ist einfache typkonvertierung im alten c-style.

aber ich habe eine frage!

was ist der unterschied zwischen beidem?
int *ret;
cout<<&ret<<endl; //0xbf947ab8
cout<<ret<<endl; //0xbf947ac8

dementsprechend unterscheidet sich die art des overflows leicht ): und ich abe keine ahnung warum!!!! der zeiger beschreibt doch einen speicherbereich.... der zugriff auf beide adressen ist auch gleich... also wenn ich so eine adresse nehmen würde und per int neu zuweise...

char* string = "hallo";
int adresse = reinterpret_cast<int>(string);
cout<<"adresse von string "<<adresse<<" = "<<&string<<endl;

char* stringCopy = reinterpret_cast<char*>(adresse);
cout<<"adresse von stringCopy = "<<&stringCopy<<endl;
cout<<stringCopy<<endl;

das ist mir echt ein rätsel, außerdem sollte man keine c-like umformung mehr beutzen!

 

[redliner]

int *ret;
cout<<&ret<<endl; //0xbf947ab8
cout<<ret<<endl; //0xbf947ac8

ähm... ret ist der wert und &ret die adresse vllt???

 

[slash-ex]

nö den wert von einem zeiger bekommt man erst mit dem dereferenzierungoperator, wie dieses beispiel zeigt!!

int *ret;
ret = new int(5);
cout<<&ret<<endl; //0xbfc2429c
cout<<ret<<endl; //0x805a880
cout<<*ret<<endl; //5

was mich auch wundert, iss: dass ich überhaupt ohne einem error an die adresse eines zeigers komme, der noch keine referenz hat. das ist echt kurios. dass ganze ändert sich aber bei einer zuweisung einer const. (logisch: error)

 

[redliner]

Also ich machma n ganz einfachen beispiel:

int main()
{
  int * pointer;
  int variable = 5;

  pointer = &variable;

  printf( "Adresse vom pointer: %x", &pointer );
  printf( "Adresse von der variable %x", pointer );
  printf( "Wert von der variable %x", *pointer );

  return 0;
}

und wenn du es in C++ style machst... "new int" legt ne variable an