Smashing the stack for fun and profit

Hallo,

Also ich hab Smashing the stack for fun and profit gelesen und wollte das selbst mal ausprobieren, aber irgendwie funktioniert das nicht. Könnt ihr mir sagen was ich falsch mache?

#include "stdio.h"
#include "Windows.h"

void Nachricht( void )
{
	MessageBox( NULL, "Nachricht", "Caption", 0 );
}

void Funktion( void )
{
	char buffer[16]; // Anfangsadresse 0x0012FF1C
	char shellcode[] =
	"\x66\x31\xc0\xb4\x40\x66\xc1\xe0\x08\xb8\x0a\x10\x66\xff\xd0";

	sprintf( buffer, "%s1abcd%c%c%c%c", 0x1C, 0xFF, 0x12, 0x00 );

}

int main(int argc, char* argv[])
{

Funktion();
	// 0x40100a
/*	_asm
	{
		xor eax,eax
		mov ah, 40h
		shl eax, 8
		mov ax, 100ah

		call eax
	}
*/
	return 0;
}

also der assembler code soll die adresse der funktion Nachricht (0x40100a) in eax bewegen und die Funktion dann aufrufen. Der auskommentierte asm code funktioniert auch. Den habe ich mit nasm assembliert und daraus den 15 byte langen shellcode erzeugt. sprintf soll jetzt den shellcode in die ersten 15 bytes des buffers kopieren, dann noch 1 zeichen und danach 4 chars für den Basepointer und danach mit der Adresse von buffer den ip überschreiben. Ich hab das Programm unter VS6 als Debug kompiliert. Mache ich irgendetwas falsch ? Könnt ihr das bei euch mal ausprobieren. Wenn ichs starte stürzt es immer nur ab

feigling

Wo kopierst du denn den shellcode in den buffer.

sprintf( buffer, "%s1abcd%c%c%c%c", 0x1C, 0xFF, 0x12, 0x00 );

"shellcode" taucht doch garnicht auf

ups, Das ist ein Tippfehler, sollte natürlich

sprintf( buffer, "%s1abcd%c%c%c%c", shellcode, 0x1C, 0xFF, 0x12, 0x00 );

sein.

Also die Rücksprungadresse wird richtig überschrieben, wenn ich es im Debugger schrittweise ausführe, springt er nach dem ret von Funktion() zu 0012FF1C und schmiert dann bei 0012FF27 ab.

0012FF1C   xor         eax,eax
0012FF1E   mov         ah,40h
0012FF20   shl         eax,8
0012FF23   mov         ax,100Ah
0012FF27   ???
0012FF28   jmp         46133F3D
0012FF2D   push        ebp
0012FF2E   inc         edx

Ist vielleicht an meinem Shellcode irgendetwas falsch? Assembliert habe ich es mit "nasm.exe -o shell.bin shell.asm" :

BITS 32

xor eax,eax
mov ah, 40h
shl eax, 8
mov ax, 100ah
call eax

wenn ich den buffer grösser mache, funktionierts aber ich versteh nicht wieso es mit buffer[16] nicht geht

void Funktion( void )
{
	char buffer[32]; // 0x0012FF0C

	char shellcode[] =
	"\x31\xc0\xb4\x40\xc1\xe0\x08\x66\xb8\x0a\x10\xff\xd0";

	sprintf( buffer, "%sAAAAAAAAAAAAAAAAAAABBBB%c%c%c%c", shellcode, 0x0C, 0xFF, 0x12, 0x00 );	
}

AJ

Die Erklärung ist ganze einfach: Klassischer Bufferoverflow

Sobald du über die Grenze von buffer hinausschreibst, überschreibst du irgendwo im Arbeitsspeicher rum, was zu undefinierten Verhalten führt (das Programm macht plötzlich komische Sachen bis hin zum Absturz).

c.rackwitz

AJ, will er das nicht gerade?

Marvus, der GCC alloziiert fuer autoarrays etwas mehr als angegeben. probier mal rum

ZuK

Es ist doch ganz einfach was da schiefgeht.mit

sprintf( buffer, "%sAAAAAAAAAAAAAAAAAAABBBB%c%c%c%c", shellcode, 0x0C, 0xFF, 0x12, 0x00 );

wird shellcode in den buffer kopiert. shellcode ist nicht 0-terminiert. Wieviel da kopiert wird ist undefiniert. Trotzdem was soll dieses blöde Spielchen (threadtitle).
K

Na klar ist shellcode[] nullterminiert, siehst du nicht richtig?

ZuK

ok

AJ

Also, du schreibst in dein Array buffer die 15 Bytes aus shellcode. Danach irgendwelche Buchstaben und dann noch Bytes.

Und was soll das bewirken?

c.rackwitz

dass der funktionsprolog ueberschrieben wird und beim verlassen der funktion nicht zurueck zum call gesprungen wird, sondern auf den shellcode gesprungen wird.

Was bedeutet der 2.Parameter bei der sprintf Funktion.
Ich hab recherchiert und raus bekommen dass er die Formatierung des strings bestimmt,aber soooo lang ??

Mfg Heiner